import { AppRouteModule } from '/@/router/types';
import type { MenuModule, Menu, AppRouteRecordRaw } from '/@/router/types';
import { findPath, treeMap } from '/@/utils/helper/treeHelper';
import { cloneDeep } from 'lodash-es';
import { isUrl } from '/@/utils/is';
import { RouteParams } from 'vue-router';
import { toRaw } from 'vue';

/**
 * 获取指定路径的所有父路径
 * @param treeData 树形数据
 * @param path 目标路径
 * @returns 父路径列表
 */
export function getAllParentPath<T = Recordable>(treeData: T[], path: string): string[] {
  // 通过路径查找对应的菜单项列表
  const menuList = findPath(treeData, (n) => n.path === path) as Menu[];
  // 如果找到了菜单项列表，则提取路径并返回
  return (menuList || []).map((item) => item.path);
}

/**
 * 将菜单项的路径加上父路径（如果没有以 / 开头，也不是一个 URL）
 * @param menus 菜单项列表
 * @param parentPath 父路径，默认为空字符串
 */
function joinParentPath(menus: Menu[], parentPath = '') {
  for (let index = 0; index < menus.length; index++) {
    const menu = menus[index];
    // https://next.router.vuejs.org/guide/essentials/nested-routes.html
    // Note that nested paths that start with / will be treated as a root path.
    // 请注意，以 / 开头的嵌套路径将被视为根路径。
    // This allows you to leverage the component nesting without having to use a nested URL.
    // 这允许你利用组件嵌套，而无需使用嵌套 URL。
    if (!(menu.path.startsWith('/') || isUrl(menu.path))) {
      // path doesn't start with /, nor is it a url, join parent path
      // 路径不以 / 开头，也不是 url，加入父路径
      menu.path = `${parentPath}/${menu.path}`;
    }
    // 如果该菜单项有子菜单，则递归处理子菜单的路径
    if (menu?.children?.length) {
      joinParentPath(menu.children, menu.meta?.hidePathForChildren ? parentPath : menu.path);
    }
  }
}

// Parsing the menu module
export function transformMenuModule(menuModule: MenuModule): Menu {
  const { menu } = menuModule;

  const menuList = [menu];

  joinParentPath(menuList);
  return menuList[0];
}

/**
 * 将路由转换为菜单项，并进行必要的修改
 *
 * @param {AppRouteModule[]} routeModList 路由模块列表
 * @param {boolean} routerMapping 是否启用路由映射
 * @returns {AppRouteRecordRaw[]} 菜单项列表
 */
export function transformRouteToMenu(routeModList: AppRouteModule[], routerMapping = false) {
  // 借助 lodash 深拷贝
  const cloneRouteModList = cloneDeep(routeModList);
  const routeList: AppRouteRecordRaw[] = [];

  // 对路由项进行修改
  cloneRouteModList.forEach((item) => {
    // 如果启用路由映射且 hideChildrenInMenu 为 true，则将路径修改为 redirect 的值
    if (routerMapping && item.meta.hideChildrenInMenu && typeof item.redirect === 'string') {
      item.path = item.redirect;
    }
    // 如果路由项有 single 属性，则将它的第一个子项作为新路由项
    if (item.meta?.single) {
      const realItem = item?.children?.[0];
      realItem && routeList.push(realItem);
    } else {
      routeList.push(item);
    }
  });

  // 提取树指定结构
  const list = treeMap(routeList, {
    conversion: (node: AppRouteRecordRaw) => {
      const { meta: { title, hideMenu = false } = {} } = node;

      return {
        ...(node.meta || {}),
        meta: node.meta,
        name: title,
        hideMenu,
        path: node.path,
        ...(node.redirect ? { redirect: node.redirect } : {}),
      };
    },
  });
  // 路径处理
  joinParentPath(list);
  return cloneDeep(list);
}

/**
 * config menu with given params
 * 这个正则表达式 /(?::)([\s\S]+?)((?=\/)|$)/g 用于匹配特定的字符串模式。我将为您逐部分地解释其含义：
 * (?:)：这是一个非捕获组，它会匹配括号中的内容，但匹配的结果不会保存为捕获组的一部分。
 * :：该符号代表自身，因此这一部分表示匹配字面上的冒号 : 符号。
 *
 * ([\s\S]+?)：这是一个捕获组。
 * [\s\S] 是一个字符集合，\s 表示任意的空白符（如空格、制表符或换行符），而 \S（大写S）表示任意的非空白符。当二者在一起时，[\s\S] 匹配任意字符。
 * +? 表示非贪婪地匹配一个或多个前面的表达式（即任意字符）。
 *
 * ((?=\/)|$)：这是另一个捕获组，其中包含两个选项，使用|分隔，它表现为逻辑"OR"关系。
 * (?=\/) 是一个正向先行断言（lookahead），它匹配一个位置，此位置之后是斜线 / 符号，但不消费文字，也就是匹配的结果中不会包含斜线。$ 代表字符串的末尾。
 * g：这是一个修饰符，表示全局搜索，即在字符串中找到所有匹配的结果，而不仅仅是第一个。
 * 将这一切组合起来，这个正则表达式的作用是：寻找字符串中以冒号 : 开头的子串，然后匹配尽可能少的任意字符，直到遇到斜线 /（但不包括斜线在内）或字符串的末尾。由于使用了全局搜索修饰符 g，它会找到所有的匹配项。
 *
 * 因此，对于字符串 test:this/is/a/test/again 会找到以下匹配结果：
 * 第一个捕获组为 this
 * 第二个捕获组为空（由于正向先行断言，斜线不被捕获），并且第一个匹配在 this 和第一个 / 之间停止。
 */
const menuParamRegex = /(?::)([\s\S]+?)((?=\/)|$)/g;

/**
 * 配置带有动态参数的菜单项。
 * @param {Menu} menu - 需要配置的菜单对象。
 * @param {RouteParams} params - 路由参数对象，包含了需要替换的动态参数值。
 */
export function configureDynamicParamsMenu(menu: Menu, params: RouteParams) {
  // 将传入的菜单对象解构为原始数据。
  const { path, paramPath } = toRaw(menu);
  let realPath = paramPath ? paramPath : path;
  // 使用正则表达式匹配路由路径中的动态参数。
  const matchArr = realPath.match(menuParamRegex);

  // 如果存在匹配的动态参数，则遍历它们以构造真实路径。
  matchArr?.forEach((it) => {
    // 去掉参数前的冒号以获取真正的参数键名。
    const realIt = it.substring(1);
    // 如果提供的路由参数中存在相应的值，则用该值替换路径中的参数占位符。
    if (params[realIt]) {
      realPath = realPath.replace(`:${realIt}`, params[realIt] as string);
    }
  });

  // 如果paramPath不存在且存在动态参数，保存原始的参数路径。
  if (!paramPath && matchArr && matchArr.length > 0) {
    menu.paramPath = path;
  }
  // 更新菜单对象的路径为真实路径。
  menu.path = realPath;

  // 如果菜单有子项，递归处理每一个子菜单。
  menu.children?.forEach((item) => configureDynamicParamsMenu(item, params));
}
